import { Syntax } from "./estraverse.js";
export { attachComments } from "./estraverse.js";
import esutilscode from "./esutilslib/code.js";
// import esutils from "./esutilslib/utils.js";
/*
  Copyright (C) 2012-2014 Yusuke Suzuki <utatane.tea@gmail.com>
  Copyright (C) 2015 Ingvar Stepanyan <me@rreverser.com>
  Copyright (C) 2014 Ivan Nikulin <ifaaan@gmail.com>
  Copyright (C) 2012-2013 Michael Ficarra <escodegen.copyright@michael.ficarra.me>
  Copyright (C) 2012-2013 Mathias Bynens <mathias@qiwi.be>
  Copyright (C) 2013 Irakli Gozalishvili <rfobic@gmail.com>
  Copyright (C) 2012 Robert Gust-Bardon <donate@robert.gust-bardon.org>
  Copyright (C) 2012 John Freeman <jfreeman08@gmail.com>
  Copyright (C) 2011-2012 Ariya Hidayat <ariya.hidayat@gmail.com>
  Copyright (C) 2012 Joost-Wim Boekesteijn <joost-wim@boekesteijn.nl>
  Copyright (C) 2012 Kris Kowal <kris.kowal@cixar.com>
  Copyright (C) 2012 Arpad Borsos <arpad.borsos@googlemail.com>

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

// /*global exports:true, require:true, global:true*/
// (function () {
("use strict");

var //Syntax,
    Precedence,
    BinaryPrecedence,
    SourceNode,
    //   estraverse,
    //   esutils,
    base,
    indent,
    json,
    renumber,
    hexadecimal,
    quotes,
    escapeless,
    newline,
    space,
    parentheses,
    semicolons,
    safeConcatenation,
    directive,
    extra,
    parse,
    sourceMap = false,
    sourceCode,
    preserveBlankLines,
    FORMAT_MINIFY,
    FORMAT_DEFAULTS;

// estraverse = require('estraverse');
// esutils = require('esutils');

// Syntax = estraverse.Syntax;

// Generation is done by generateExpression.
function isExpression(node) {
    return CodeGenerator.Expression.hasOwnProperty(node.type);
}

// Generation is done by generateStatement.
function isStatement(node) {
    return CodeGenerator.Statement.hasOwnProperty(node.type);
}

Precedence = {
    Sequence: 0,
    Yield: 1,
    Assignment: 1,
    Conditional: 2,
    ArrowFunction: 2,
    LogicalOR: 3,
    LogicalAND: 4,
    BitwiseOR: 5,
    BitwiseXOR: 6,
    BitwiseAND: 7,
    Equality: 8,
    Relational: 9,
    BitwiseSHIFT: 10,
    Additive: 11,
    Multiplicative: 12,
    Await: 13,
    Unary: 13,
    Postfix: 14,
    Call: 15,
    New: 16,
    TaggedTemplate: 17,
    Member: 18,
    Primary: 19,
};

BinaryPrecedence = {
    "||": Precedence.LogicalOR,
    "&&": Precedence.LogicalAND,
    "|": Precedence.BitwiseOR,
    "^": Precedence.BitwiseXOR,
    "&": Precedence.BitwiseAND,
    "==": Precedence.Equality,
    "!=": Precedence.Equality,
    "===": Precedence.Equality,
    "!==": Precedence.Equality,
    is: Precedence.Equality,
    isnt: Precedence.Equality,
    "<": Precedence.Relational,
    ">": Precedence.Relational,
    "<=": Precedence.Relational,
    ">=": Precedence.Relational,
    in: Precedence.Relational,
    instanceof: Precedence.Relational,
    "<<": Precedence.BitwiseSHIFT,
    ">>": Precedence.BitwiseSHIFT,
    ">>>": Precedence.BitwiseSHIFT,
    "+": Precedence.Additive,
    "-": Precedence.Additive,
    "*": Precedence.Multiplicative,
    "%": Precedence.Multiplicative,
    "/": Precedence.Multiplicative,
};

//Flags
var F_ALLOW_IN = 1,
    F_ALLOW_CALL = 1 << 1,
    F_ALLOW_UNPARATH_NEW = 1 << 2,
    F_FUNC_BODY = 1 << 3,
    F_DIRECTIVE_CTX = 1 << 4,
    F_SEMICOLON_OPT = 1 << 5;

//Expression flag sets
//NOTE: Flag order:
// F_ALLOW_IN
// F_ALLOW_CALL
// F_ALLOW_UNPARATH_NEW
var E_FTT = F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW,
    E_TTF = F_ALLOW_IN | F_ALLOW_CALL,
    E_TTT = F_ALLOW_IN | F_ALLOW_CALL | F_ALLOW_UNPARATH_NEW,
    E_TFF = F_ALLOW_IN,
    E_FFT = F_ALLOW_UNPARATH_NEW,
    E_TFT = F_ALLOW_IN | F_ALLOW_UNPARATH_NEW;

//Statement flag sets
//NOTE: Flag order:
// F_ALLOW_IN
// F_FUNC_BODY
// F_DIRECTIVE_CTX
// F_SEMICOLON_OPT
var S_TFFF = F_ALLOW_IN,
    S_TFFT = F_ALLOW_IN | F_SEMICOLON_OPT,
    S_FFFF = 0x00,
    S_TFTF = F_ALLOW_IN | F_DIRECTIVE_CTX,
    S_TTFF = F_ALLOW_IN | F_FUNC_BODY;

function getDefaultOptions() {
    // default options
    return {
        indent: null,
        base: null,
        parse: null,
        comment: false,
        format: {
            indent: {
                style: "    ",
                base: 0,
                adjustMultilineComment: false,
            },
            newline: "\n",
            space: " ",
            json: false,
            renumber: false,
            hexadecimal: false,
            quotes: "single",
            escapeless: false,
            compact: false,
            parentheses: true,
            semicolons: true,
            safeConcatenation: false,
            preserveBlankLines: false,
        },
        moz: {
            comprehensionExpressionStartsWithAssignment: false,
            starlessGenerator: false,
        },
        sourceMap: null,
        sourceMapRoot: null,
        sourceMapWithCode: false,
        directive: false,
        raw: true,
        verbatim: null,
        sourceCode: null,
    };
}

function stringRepeat(str, num) {
    var result = "";

    for (num |= 0; num > 0; num >>>= 1, str += str) {
        if (num & 1) {
            result += str;
        }
    }

    return result;
}

function hasLineTerminator(str) {
    return /[\r\n]/g.test(str);
}

function endsWithLineTerminator(str) {
    var len = str.length;
    return len && esutilscode.isLineTerminator(str.charCodeAt(len - 1));
}

function merge(target, override) {
    var key;
    for (key in override) {
        if (override.hasOwnProperty(key)) {
            target[key] = override[key];
        }
    }
    return target;
}

function updateDeeply(target, override) {
    var key, val;

    function isHashObject(target) {
        return (
            typeof target === "object" &&
            target instanceof Object &&
            !(target instanceof RegExp)
        );
    }

    for (key in override) {
        if (override.hasOwnProperty(key)) {
            val = override[key];
            if (isHashObject(val)) {
                if (isHashObject(target[key])) {
                    updateDeeply(target[key], val);
                } else {
                    target[key] = updateDeeply({}, val);
                }
            } else {
                target[key] = val;
            }
        }
    }
    return target;
}

function generateNumber(value) {
    var result, point, temp, exponent, pos;

    if (value !== value) {
        throw new Error("Numeric literal whose value is NaN");
    }
    if (value < 0 || (value === 0 && 1 / value < 0)) {
        throw new Error("Numeric literal whose value is negative");
    }

    if (value === 1 / 0) {
        return json ? "null" : renumber ? "1e400" : "1e+400";
    }

    result = "" + value;
    if (!renumber || result.length < 3) {
        return result;
    }

    point = result.indexOf(".");
    if (!json && result.charCodeAt(0) === 0x30 /* 0 */ && point === 1) {
        point = 0;
        result = result.slice(1);
    }
    temp = result;
    result = result.replace("e+", "e");
    exponent = 0;
    if ((pos = temp.indexOf("e")) > 0) {
        exponent = +temp.slice(pos + 1);
        temp = temp.slice(0, pos);
    }
    if (point >= 0) {
        exponent -= temp.length - point - 1;
        temp = +(temp.slice(0, point) + temp.slice(point + 1)) + "";
    }
    pos = 0;
    while (temp.charCodeAt(temp.length + pos - 1) === 0x30 /* 0 */) {
        --pos;
    }
    if (pos !== 0) {
        exponent -= pos;
        temp = temp.slice(0, pos);
    }
    if (exponent !== 0) {
        temp += "e" + exponent;
    }
    if (
        (temp.length < result.length ||
            (hexadecimal &&
                value > 1e12 &&
                Math.floor(value) === value &&
                (temp = "0x" + value.toString(16)).length < result.length)) &&
        +temp === value
    ) {
        result = temp;
    }

    return result;
}

// Generate valid RegExp expression.
// This function is based on https://github.com/Constellation/iv Engine

function escapeRegExpCharacter(ch, previousIsBackslash) {
    // not handling '\' and handling \u2028 or \u2029 to unicode escape sequence
    if ((ch & ~1) === 0x2028) {
        return (
            (previousIsBackslash ? "u" : "\\u") +
            (ch === 0x2028 ? "2028" : "2029")
        );
    } else if (ch === 10 || ch === 13) {
        // \n, \r
        return (previousIsBackslash ? "" : "\\") + (ch === 10 ? "n" : "r");
    }
    return String.fromCharCode(ch);
}

function generateRegExp(reg) {
    var match, result, flags, i, iz, ch, characterInBrack, previousIsBackslash;

    result = reg.toString();

    if (reg.source) {
        // extract flag from toString result
        match = result.match(/\/([^/]*)$/);
        if (!match) {
            return result;
        }

        flags = match[1];
        result = "";

        characterInBrack = false;
        previousIsBackslash = false;
        for (i = 0, iz = reg.source.length; i < iz; ++i) {
            ch = reg.source.charCodeAt(i);

            if (!previousIsBackslash) {
                if (characterInBrack) {
                    if (ch === 93) {
                        // ]
                        characterInBrack = false;
                    }
                } else {
                    if (ch === 47) {
                        // /
                        result += "\\";
                    } else if (ch === 91) {
                        // [
                        characterInBrack = true;
                    }
                }
                result += escapeRegExpCharacter(ch, previousIsBackslash);
                previousIsBackslash = ch === 92; // \
            } else {
                // if new RegExp("\\\n') is provided, create /\n/
                result += escapeRegExpCharacter(ch, previousIsBackslash);
                // prevent like /\\[/]/
                previousIsBackslash = false;
            }
        }

        return "/" + result + "/" + flags;
    }

    return result;
}

function escapeAllowedCharacter(code, next) {
    var hex;

    if (code === 0x08 /* \b */) {
        return "\\b";
    }

    if (code === 0x0c /* \f */) {
        return "\\f";
    }

    if (code === 0x09 /* \t */) {
        return "\\t";
    }

    hex = code.toString(16).toUpperCase();
    if (json || code > 0xff) {
        return "\\u" + "0000".slice(hex.length) + hex;
    } else if (code === 0x0000 && !esutilscode.isDecimalDigit(next)) {
        return "\\0";
    } else if (code === 0x000b /* \v */) {
        // '\v'
        return "\\x0B";
    } else {
        return "\\x" + "00".slice(hex.length) + hex;
    }
}

function escapeDisallowedCharacter(code) {
    if (code === 0x5c /* \ */) {
        return "\\\\";
    }

    if (code === 0x0a /* \n */) {
        return "\\n";
    }

    if (code === 0x0d /* \r */) {
        return "\\r";
    }

    if (code === 0x2028) {
        return "\\u2028";
    }

    if (code === 0x2029) {
        return "\\u2029";
    }

    throw new Error("Incorrectly classified character");
}

function escapeDirective(str) {
    var i, iz, code, quote;

    quote = quotes === "double" ? '"' : "'";
    for (i = 0, iz = str.length; i < iz; ++i) {
        code = str.charCodeAt(i);
        if (code === 0x27 /* ' */) {
            quote = '"';
            break;
        } else if (code === 0x22 /* " */) {
            quote = "'";
            break;
        } else if (code === 0x5c /* \ */) {
            ++i;
        }
    }

    return quote + str + quote;
}

function escapeString(str) {
    var result = "",
        i,
        len,
        code,
        singleQuotes = 0,
        doubleQuotes = 0,
        single,
        quote;

    for (i = 0, len = str.length; i < len; ++i) {
        code = str.charCodeAt(i);
        if (code === 0x27 /* ' */) {
            ++singleQuotes;
        } else if (code === 0x22 /* " */) {
            ++doubleQuotes;
        } else if (code === 0x2f /* / */ && json) {
            result += "\\";
        } else if (
            esutilscode.isLineTerminator(code) ||
            code === 0x5c /* \ */
        ) {
            result += escapeDisallowedCharacter(code);
            continue;
        } else if (
            !esutilscode.isIdentifierPartES5(code) &&
            ((json && code < 0x20) /* SP */ ||
                (!json &&
                    !escapeless &&
                    (code < 0x20 /* SP */ || code > 0x7e))) /* ~ */
        ) {
            result += escapeAllowedCharacter(code, str.charCodeAt(i + 1));
            continue;
        }
        result += String.fromCharCode(code);
    }

    single = !(
        quotes === "double" ||
        (quotes === "auto" && doubleQuotes < singleQuotes)
    );
    quote = single ? "'" : '"';

    if (!(single ? singleQuotes : doubleQuotes)) {
        return quote + result + quote;
    }

    str = result;
    result = quote;

    for (i = 0, len = str.length; i < len; ++i) {
        code = str.charCodeAt(i);
        if (
            (code === 0x27 /* ' */ && single) ||
            (code === 0x22 /* " */ && !single)
        ) {
            result += "\\";
        }
        result += String.fromCharCode(code);
    }

    return result + quote;
}

/**
 * flatten an array to a string, where the array can contain
 * either strings or nested arrays
 */
function flattenToString(arr) {
    var i,
        iz,
        elem,
        result = "";
    for (i = 0, iz = arr.length; i < iz; ++i) {
        elem = arr[i];
        result += Array.isArray(elem) ? flattenToString(elem) : elem;
    }
    return result;
}

/**
 * convert generated to a SourceNode when source maps are enabled.
 */
function toSourceNodeWhenNeeded(generated, node) {
    if (!sourceMap) {
        // with no source maps, generated is either an
        // array or a string.  if an array, flatten it.
        // if a string, just return it
        if (Array.isArray(generated)) {
            return flattenToString(generated);
        } else {
            return generated;
        }
    }
    if (node == null) {
        if (generated instanceof SourceNode) {
            return generated;
        } else {
            node = {};
        }
    }
    if (node.loc == null) {
        return new SourceNode(
            null,
            null,
            sourceMap,
            generated,
            node.name || null
        );
    }
    return new SourceNode(
        node.loc.start.line,
        node.loc.start.column,
        sourceMap === true ? node.loc.source || null : sourceMap,
        generated,
        node.name || null
    );
}

function noEmptySpace() {
    return space ? space : " ";
}

function join(left, right) {
    var leftSource, rightSource, leftCharCode, rightCharCode;

    leftSource = toSourceNodeWhenNeeded(left).toString();
    if (leftSource.length === 0) {
        return [right];
    }

    rightSource = toSourceNodeWhenNeeded(right).toString();
    if (rightSource.length === 0) {
        return [left];
    }

    leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
    rightCharCode = rightSource.charCodeAt(0);

    if (
        ((leftCharCode === 0x2b /* + */ || leftCharCode === 0x2d) /* - */ &&
            leftCharCode === rightCharCode) ||
        (esutilscode.isIdentifierPartES5(leftCharCode) &&
            esutilscode.isIdentifierPartES5(rightCharCode)) ||
        (leftCharCode === 0x2f /* / */ && rightCharCode === 0x69) /* i */
    ) {
        // infix word operators all start with `i`
        return [left, noEmptySpace(), right];
    } else if (
        esutilscode.isWhiteSpace(leftCharCode) ||
        esutilscode.isLineTerminator(leftCharCode) ||
        esutilscode.isWhiteSpace(rightCharCode) ||
        esutilscode.isLineTerminator(rightCharCode)
    ) {
        return [left, right];
    }
    return [left, space, right];
}

function addIndent(stmt) {
    return [base, stmt];
}

function withIndent(fn) {
    var previousBase;
    previousBase = base;
    base += indent;
    fn(base);
    base = previousBase;
}

function calculateSpaces(str) {
    var i;
    for (i = str.length - 1; i >= 0; --i) {
        if (esutilscode.isLineTerminator(str.charCodeAt(i))) {
            break;
        }
    }
    return str.length - 1 - i;
}

function adjustMultilineComment(value, specialBase) {
    var array, i, len, line, j, spaces, previousBase, sn;

    array = value.split(/\r\n|[\r\n]/);
    spaces = Number.MAX_VALUE;

    // first line doesn't have indentation
    for (i = 1, len = array.length; i < len; ++i) {
        line = array[i];
        j = 0;
        while (
            j < line.length &&
            esutilscode.isWhiteSpace(line.charCodeAt(j))
        ) {
            ++j;
        }
        if (spaces > j) {
            spaces = j;
        }
    }

    if (typeof specialBase !== "undefined") {
        // pattern like
        // {
        //   var t = 20;  /*
        //                 * this is comment
        //                 */
        // }
        previousBase = base;
        if (array[1][spaces] === "*") {
            specialBase += " ";
        }
        base = specialBase;
    } else {
        if (spaces & 1) {
            // /*
            //  *
            //  */
            // If spaces are odd number, above pattern is considered.
            // We waste 1 space.
            --spaces;
        }
        previousBase = base;
    }

    for (i = 1, len = array.length; i < len; ++i) {
        sn = toSourceNodeWhenNeeded(addIndent(array[i].slice(spaces)));
        array[i] = sourceMap ? sn.join("") : sn;
    }

    base = previousBase;

    return array.join("\n");
}

function generateComment(comment, specialBase) {
    if (comment.type === "Line") {
        if (endsWithLineTerminator(comment.value)) {
            return "//" + comment.value;
        } else {
            // Always use LineTerminator
            var result = "//" + comment.value;
            if (!preserveBlankLines) {
                result += "\n";
            }
            return result;
        }
    }
    if (
        extra.format.indent.adjustMultilineComment &&
        /[\n\r]/.test(comment.value)
    ) {
        return adjustMultilineComment("/*" + comment.value + "*/", specialBase);
    }
    return "/*" + comment.value + "*/";
}

function addComments(stmt, result) {
    var i,
        len,
        comment,
        save,
        tailingToStatement,
        specialBase,
        fragment,
        extRange,
        range,
        prevRange,
        prefix,
        infix,
        suffix,
        count;

    if (stmt.leadingComments && stmt.leadingComments.length > 0) {
        save = result;

        if (preserveBlankLines) {
            comment = stmt.leadingComments[0];
            result = [];

            extRange = comment.extendedRange;
            range = comment.range;

            prefix = sourceCode.substring(extRange[0], range[0]);
            count = (prefix.match(/\n/g) || []).length;
            if (count > 0) {
                result.push(stringRepeat("\n", count));
                result.push(addIndent(generateComment(comment)));
            } else {
                result.push(prefix);
                result.push(generateComment(comment));
            }

            prevRange = range;

            for (i = 1, len = stmt.leadingComments.length; i < len; i++) {
                comment = stmt.leadingComments[i];
                range = comment.range;

                infix = sourceCode.substring(prevRange[1], range[0]);
                count = (infix.match(/\n/g) || []).length;
                result.push(stringRepeat("\n", count));
                result.push(addIndent(generateComment(comment)));

                prevRange = range;
            }

            suffix = sourceCode.substring(range[1], extRange[1]);
            count = (suffix.match(/\n/g) || []).length;
            result.push(stringRepeat("\n", count));
        } else {
            comment = stmt.leadingComments[0];
            result = [];
            if (
                safeConcatenation &&
                stmt.type === Syntax.Program &&
                stmt.body.length === 0
            ) {
                result.push("\n");
            }
            result.push(generateComment(comment));
            if (
                !endsWithLineTerminator(
                    toSourceNodeWhenNeeded(result).toString()
                )
            ) {
                result.push("\n");
            }

            for (i = 1, len = stmt.leadingComments.length; i < len; ++i) {
                comment = stmt.leadingComments[i];
                fragment = [generateComment(comment)];
                if (
                    !endsWithLineTerminator(
                        toSourceNodeWhenNeeded(fragment).toString()
                    )
                ) {
                    fragment.push("\n");
                }
                result.push(addIndent(fragment));
            }
        }

        result.push(addIndent(save));
    }

    if (stmt.trailingComments) {
        if (preserveBlankLines) {
            comment = stmt.trailingComments[0];
            extRange = comment.extendedRange;
            range = comment.range;

            prefix = sourceCode.substring(extRange[0], range[0]);
            count = (prefix.match(/\n/g) || []).length;

            if (count > 0) {
                result.push(stringRepeat("\n", count));
                result.push(addIndent(generateComment(comment)));
            } else {
                result.push(prefix);
                result.push(generateComment(comment));
            }
        } else {
            tailingToStatement = !endsWithLineTerminator(
                toSourceNodeWhenNeeded(result).toString()
            );
            specialBase = stringRepeat(
                " ",
                calculateSpaces(
                    toSourceNodeWhenNeeded([base, result, indent]).toString()
                )
            );
            for (i = 0, len = stmt.trailingComments.length; i < len; ++i) {
                comment = stmt.trailingComments[i];
                if (tailingToStatement) {
                    // We assume target like following script
                    //
                    // var t = 20;  /**
                    //               * This is comment of t
                    //               */
                    if (i === 0) {
                        // first case
                        result = [result, indent];
                    } else {
                        result = [result, specialBase];
                    }
                    result.push(generateComment(comment, specialBase));
                } else {
                    result = [result, addIndent(generateComment(comment))];
                }
                if (
                    i !== len - 1 &&
                    !endsWithLineTerminator(
                        toSourceNodeWhenNeeded(result).toString()
                    )
                ) {
                    result = [result, "\n"];
                }
            }
        }
    }

    return result;
}

function generateBlankLines(start, end, result) {
    var j,
        newlineCount = 0;

    for (j = start; j < end; j++) {
        if (sourceCode[j] === "\n") {
            newlineCount++;
        }
    }

    for (j = 1; j < newlineCount; j++) {
        result.push(newline);
    }
}

function parenthesize(text, current, should) {
    if (current < should) {
        return ["(", text, ")"];
    }
    return text;
}

function generateVerbatimString(string) {
    var i, iz, result;
    result = string.split(/\r\n|\n/);
    for (i = 1, iz = result.length; i < iz; i++) {
        result[i] = newline + base + result[i];
    }
    return result;
}

function generateVerbatim(expr, precedence) {
    var verbatim, result, prec;
    verbatim = expr[extra.verbatim];

    if (typeof verbatim === "string") {
        result = parenthesize(
            generateVerbatimString(verbatim),
            Precedence.Sequence,
            precedence
        );
    } else {
        // verbatim is object
        result = generateVerbatimString(verbatim.content);
        prec =
            verbatim.precedence != null
                ? verbatim.precedence
                : Precedence.Sequence;
        result = parenthesize(result, prec, precedence);
    }

    return toSourceNodeWhenNeeded(result, expr);
}

function CodeGenerator() {}

// Helpers.

CodeGenerator.prototype.maybeBlock = function (stmt, flags) {
    var result,
        noLeadingComment,
        that = this;

    noLeadingComment = !extra.comment || !stmt.leadingComments;

    if (stmt.type === Syntax.BlockStatement && noLeadingComment) {
        return [space, this.generateStatement(stmt, flags)];
    }

    if (stmt.type === Syntax.EmptyStatement && noLeadingComment) {
        return ";";
    }

    withIndent(function () {
        result = [newline, addIndent(that.generateStatement(stmt, flags))];
    });

    return result;
};

CodeGenerator.prototype.maybeBlockSuffix = function (stmt, result) {
    var ends = endsWithLineTerminator(
        toSourceNodeWhenNeeded(result).toString()
    );
    if (
        stmt.type === Syntax.BlockStatement &&
        (!extra.comment || !stmt.leadingComments) &&
        !ends
    ) {
        return [result, space];
    }
    if (ends) {
        return [result, base];
    }
    return [result, newline, base];
};

function generateIdentifier(node) {
    return toSourceNodeWhenNeeded(node.name, node);
}

function generateAsyncPrefix(node, spaceRequired) {
    return node.async ? "async" + (spaceRequired ? noEmptySpace() : space) : "";
}

function generateStarSuffix(node) {
    var isGenerator = node.generator && !extra.moz.starlessGenerator;
    return isGenerator ? "*" + space : "";
}

function generateMethodPrefix(prop) {
    var func = prop.value,
        prefix = "";
    if (func.async) {
        prefix += generateAsyncPrefix(func, !prop.computed);
    }
    if (func.generator) {
        // avoid space before method name
        prefix += generateStarSuffix(func) ? "*" : "";
    }
    return prefix;
}

CodeGenerator.prototype.generatePattern = function (node, precedence, flags) {
    if (node.type === Syntax.Identifier) {
        return generateIdentifier(node);
    }
    return this.generateExpression(node, precedence, flags);
};

CodeGenerator.prototype.generateFunctionParams = function (node) {
    var i, iz, result, hasDefault;

    hasDefault = false;

    if (
        node.type === Syntax.ArrowFunctionExpression &&
        !node.rest &&
        (!node.defaults || node.defaults.length === 0) &&
        node.params.length === 1 &&
        node.params[0].type === Syntax.Identifier
    ) {
        // arg => { } case
        result = [
            generateAsyncPrefix(node, true),
            generateIdentifier(node.params[0]),
        ];
    } else {
        result =
            node.type === Syntax.ArrowFunctionExpression
                ? [generateAsyncPrefix(node, false)]
                : [];
        result.push("(");
        if (node.defaults) {
            hasDefault = true;
        }
        for (i = 0, iz = node.params.length; i < iz; ++i) {
            if (hasDefault && node.defaults[i]) {
                // Handle default values.
                result.push(
                    this.generateAssignment(
                        node.params[i],
                        node.defaults[i],
                        "=",
                        Precedence.Assignment,
                        E_TTT
                    )
                );
            } else {
                result.push(
                    this.generatePattern(
                        node.params[i],
                        Precedence.Assignment,
                        E_TTT
                    )
                );
            }
            if (i + 1 < iz) {
                result.push("," + space);
            }
        }

        if (node.rest) {
            if (node.params.length) {
                result.push("," + space);
            }
            result.push("...");
            result.push(generateIdentifier(node.rest));
        }

        result.push(")");
    }

    return result;
};

CodeGenerator.prototype.generateFunctionBody = function (node) {
    var result, expr;

    result = this.generateFunctionParams(node);

    if (node.type === Syntax.ArrowFunctionExpression) {
        result.push(space);
        result.push("=>");
    }

    if (node.expression) {
        result.push(space);
        expr = this.generateExpression(node.body, Precedence.Assignment, E_TTT);
        if (expr.toString().charAt(0) === "{") {
            expr = ["(", expr, ")"];
        }
        result.push(expr);
    } else {
        result.push(this.maybeBlock(node.body, S_TTFF));
    }

    return result;
};

CodeGenerator.prototype.generateIterationForStatement = function (
    operator,
    stmt,
    flags
) {
    var result = ["for" + space + (stmt.await ? "await" + space : "") + "("],
        that = this;
    withIndent(function () {
        if (stmt.left.type === Syntax.VariableDeclaration) {
            withIndent(function () {
                result.push(stmt.left.kind + noEmptySpace());
                result.push(
                    that.generateStatement(stmt.left.declarations[0], S_FFFF)
                );
            });
        } else {
            result.push(
                that.generateExpression(stmt.left, Precedence.Call, E_TTT)
            );
        }

        result = join(result, operator);
        result = [
            join(
                result,
                that.generateExpression(
                    stmt.right,
                    Precedence.Assignment,
                    E_TTT
                )
            ),
            ")",
        ];
    });
    result.push(this.maybeBlock(stmt.body, flags));
    return result;
};

CodeGenerator.prototype.generatePropertyKey = function (expr, computed) {
    var result = [];

    if (computed) {
        result.push("[");
    }

    result.push(this.generateExpression(expr, Precedence.Sequence, E_TTT));

    if (computed) {
        result.push("]");
    }

    return result;
};

CodeGenerator.prototype.generateAssignment = function (
    left,
    right,
    operator,
    precedence,
    flags
) {
    if (Precedence.Assignment < precedence) {
        flags |= F_ALLOW_IN;
    }

    return parenthesize(
        [
            this.generateExpression(left, Precedence.Call, flags),
            space + operator + space,
            this.generateExpression(right, Precedence.Assignment, flags),
        ],
        Precedence.Assignment,
        precedence
    );
};

CodeGenerator.prototype.semicolon = function (flags) {
    if (!semicolons && flags & F_SEMICOLON_OPT) {
        return "";
    }
    return ";";
};

// Statements.

CodeGenerator.Statement = {
    BlockStatement: function (stmt, flags) {
        var range,
            content,
            result = ["{", newline],
            that = this;

        withIndent(function () {
            // handle functions without any code
            if (stmt.body.length === 0 && preserveBlankLines) {
                range = stmt.range;
                if (range[1] - range[0] > 2) {
                    content = sourceCode.substring(range[0] + 1, range[1] - 1);
                    if (content[0] === "\n") {
                        result = ["{"];
                    }
                    result.push(content);
                }
            }

            var i, iz, fragment, bodyFlags;
            bodyFlags = S_TFFF;
            if (flags & F_FUNC_BODY) {
                bodyFlags |= F_DIRECTIVE_CTX;
            }

            for (i = 0, iz = stmt.body.length; i < iz; ++i) {
                if (preserveBlankLines) {
                    // handle spaces before the first line
                    if (i === 0) {
                        if (stmt.body[0].leadingComments) {
                            range =
                                stmt.body[0].leadingComments[0].extendedRange;
                            content = sourceCode.substring(range[0], range[1]);
                            if (content[0] === "\n") {
                                result = ["{"];
                            }
                        }
                        if (!stmt.body[0].leadingComments) {
                            generateBlankLines(
                                stmt.range[0],
                                stmt.body[0].range[0],
                                result
                            );
                        }
                    }

                    // handle spaces between lines
                    if (i > 0) {
                        if (
                            !stmt.body[i - 1].trailingComments &&
                            !stmt.body[i].leadingComments
                        ) {
                            generateBlankLines(
                                stmt.body[i - 1].range[1],
                                stmt.body[i].range[0],
                                result
                            );
                        }
                    }
                }

                if (i === iz - 1) {
                    bodyFlags |= F_SEMICOLON_OPT;
                }

                if (stmt.body[i].leadingComments && preserveBlankLines) {
                    fragment = that.generateStatement(stmt.body[i], bodyFlags);
                } else {
                    fragment = addIndent(
                        that.generateStatement(stmt.body[i], bodyFlags)
                    );
                }

                result.push(fragment);
                if (
                    !endsWithLineTerminator(
                        toSourceNodeWhenNeeded(fragment).toString()
                    )
                ) {
                    if (preserveBlankLines && i < iz - 1) {
                        // don't add a new line if there are leading coments
                        // in the next statement
                        if (!stmt.body[i + 1].leadingComments) {
                            result.push(newline);
                        }
                    } else {
                        result.push(newline);
                    }
                }

                if (preserveBlankLines) {
                    // handle spaces after the last line
                    if (i === iz - 1) {
                        if (!stmt.body[i].trailingComments) {
                            generateBlankLines(
                                stmt.body[i].range[1],
                                stmt.range[1],
                                result
                            );
                        }
                    }
                }
            }
        });

        result.push(addIndent("}"));
        return result;
    },

    BreakStatement: function (stmt, flags) {
        if (stmt.label) {
            return "break " + stmt.label.name + this.semicolon(flags);
        }
        return "break" + this.semicolon(flags);
    },

    ContinueStatement: function (stmt, flags) {
        if (stmt.label) {
            return "continue " + stmt.label.name + this.semicolon(flags);
        }
        return "continue" + this.semicolon(flags);
    },

    ClassBody: function (stmt) {
        var result = ["{", newline],
            that = this;

        withIndent(function (indent) {
            var i, iz;

            for (i = 0, iz = stmt.body.length; i < iz; ++i) {
                result.push(indent);
                result.push(
                    that.generateExpression(
                        stmt.body[i],
                        Precedence.Sequence,
                        E_TTT
                    )
                );
                if (i + 1 < iz) {
                    result.push(newline);
                }
            }
        });

        if (
            !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())
        ) {
            result.push(newline);
        }
        result.push(base);
        result.push("}");
        return result;
    },

    ClassDeclaration: function (stmt) {
        var result, fragment;
        result = ["class"];
        if (stmt.id) {
            result = join(
                result,
                this.generateExpression(stmt.id, Precedence.Sequence, E_TTT)
            );
        }
        if (stmt.superClass) {
            fragment = join(
                "extends",
                this.generateExpression(
                    stmt.superClass,
                    Precedence.Assignment,
                    E_TTT
                )
            );
            result = join(result, fragment);
        }
        result.push(space);
        result.push(this.generateStatement(stmt.body, S_TFFT));
        return result;
    },

    DirectiveStatement: function (stmt, flags) {
        if (extra.raw && stmt.raw) {
            return stmt.raw + this.semicolon(flags);
        }
        return escapeDirective(stmt.directive) + this.semicolon(flags);
    },

    DoWhileStatement: function (stmt, flags) {
        // Because `do 42 while (cond)` is Syntax Error. We need semicolon.
        var result = join("do", this.maybeBlock(stmt.body, S_TFFF));
        result = this.maybeBlockSuffix(stmt.body, result);
        return join(result, [
            "while" + space + "(",
            this.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
            ")" + this.semicolon(flags),
        ]);
    },

    CatchClause: function (stmt) {
        var result,
            that = this;
        withIndent(function () {
            var guard;

            result = [
                "catch" + space + "(",
                that.generateExpression(stmt.param, Precedence.Sequence, E_TTT),
                ")",
            ];

            if (stmt.guard) {
                guard = that.generateExpression(
                    stmt.guard,
                    Precedence.Sequence,
                    E_TTT
                );
                result.splice(2, 0, " if ", guard);
            }
        });
        result.push(this.maybeBlock(stmt.body, S_TFFF));
        return result;
    },

    DebuggerStatement: function (stmt, flags) {
        return "debugger" + this.semicolon(flags);
    },

    EmptyStatement: function () {
        return ";";
    },

    ExportDefaultDeclaration: function (stmt, flags) {
        var result = ["export"],
            bodyFlags;

        bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;

        // export default HoistableDeclaration[Default]
        // export default AssignmentExpression[In] ;
        result = join(result, "default");
        if (isStatement(stmt.declaration)) {
            result = join(
                result,
                this.generateStatement(stmt.declaration, bodyFlags)
            );
        } else {
            result = join(
                result,
                this.generateExpression(
                    stmt.declaration,
                    Precedence.Assignment,
                    E_TTT
                ) + this.semicolon(flags)
            );
        }
        return result;
    },

    ExportNamedDeclaration: function (stmt, flags) {
        var result = ["export"],
            bodyFlags,
            that = this;

        bodyFlags = flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF;

        // export VariableStatement
        // export Declaration[Default]
        if (stmt.declaration) {
            return join(
                result,
                this.generateStatement(stmt.declaration, bodyFlags)
            );
        }

        // export ExportClause[NoReference] FromClause ;
        // export ExportClause ;
        if (stmt.specifiers) {
            if (stmt.specifiers.length === 0) {
                result = join(result, "{" + space + "}");
            } else if (
                stmt.specifiers[0].type === Syntax.ExportBatchSpecifier
            ) {
                result = join(
                    result,
                    this.generateExpression(
                        stmt.specifiers[0],
                        Precedence.Sequence,
                        E_TTT
                    )
                );
            } else {
                result = join(result, "{");
                withIndent(function (indent) {
                    var i, iz;
                    result.push(newline);
                    for (i = 0, iz = stmt.specifiers.length; i < iz; ++i) {
                        result.push(indent);
                        result.push(
                            that.generateExpression(
                                stmt.specifiers[i],
                                Precedence.Sequence,
                                E_TTT
                            )
                        );
                        if (i + 1 < iz) {
                            result.push("," + newline);
                        }
                    }
                });
                if (
                    !endsWithLineTerminator(
                        toSourceNodeWhenNeeded(result).toString()
                    )
                ) {
                    result.push(newline);
                }
                result.push(base + "}");
            }

            if (stmt.source) {
                result = join(result, [
                    "from" + space,
                    // ModuleSpecifier
                    this.generateExpression(
                        stmt.source,
                        Precedence.Sequence,
                        E_TTT
                    ),
                    this.semicolon(flags),
                ]);
            } else {
                result.push(this.semicolon(flags));
            }
        }
        return result;
    },

    ExportAllDeclaration: function (stmt, flags) {
        // export * FromClause ;
        return [
            "export" + space,
            "*" + space,
            "from" + space,
            // ModuleSpecifier
            this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
            this.semicolon(flags),
        ];
    },

    ExpressionStatement: function (stmt, flags) {
        var result, fragment;

        function isClassPrefixed(fragment) {
            var code;
            if (fragment.slice(0, 5) !== "class") {
                return false;
            }
            code = fragment.charCodeAt(5);
            return (
                code === 0x7b /* '{' */ ||
                esutilscode.isWhiteSpace(code) ||
                esutilscode.isLineTerminator(code)
            );
        }

        function isFunctionPrefixed(fragment) {
            var code;
            if (fragment.slice(0, 8) !== "function") {
                return false;
            }
            code = fragment.charCodeAt(8);
            return (
                code === 0x28 /* '(' */ ||
                esutilscode.isWhiteSpace(code) ||
                code === 0x2a /* '*' */ ||
                esutilscode.isLineTerminator(code)
            );
        }

        function isAsyncPrefixed(fragment) {
            var code, i, iz;
            if (fragment.slice(0, 5) !== "async") {
                return false;
            }
            if (!esutilscode.isWhiteSpace(fragment.charCodeAt(5))) {
                return false;
            }
            for (i = 6, iz = fragment.length; i < iz; ++i) {
                if (!esutilscode.isWhiteSpace(fragment.charCodeAt(i))) {
                    break;
                }
            }
            if (i === iz) {
                return false;
            }
            if (fragment.slice(i, i + 8) !== "function") {
                return false;
            }
            code = fragment.charCodeAt(i + 8);
            return (
                code === 0x28 /* '(' */ ||
                esutilscode.isWhiteSpace(code) ||
                code === 0x2a /* '*' */ ||
                esutilscode.isLineTerminator(code)
            );
        }

        result = [
            this.generateExpression(
                stmt.expression,
                Precedence.Sequence,
                E_TTT
            ),
        ];
        // 12.4 '{', 'function', 'class' is not allowed in this position.
        // wrap expression with parentheses
        fragment = toSourceNodeWhenNeeded(result).toString();
        if (
            fragment.charCodeAt(0) === 0x7b /* '{' */ || // ObjectExpression
            isClassPrefixed(fragment) ||
            isFunctionPrefixed(fragment) ||
            isAsyncPrefixed(fragment) ||
            (directive &&
                flags & F_DIRECTIVE_CTX &&
                stmt.expression.type === Syntax.Literal &&
                typeof stmt.expression.value === "string")
        ) {
            result = ["(", result, ")" + this.semicolon(flags)];
        } else {
            result.push(this.semicolon(flags));
        }
        return result;
    },

    ImportDeclaration: function (stmt, flags) {
        // ES6: 15.2.1 valid import declarations:
        //     - import ImportClause FromClause ;
        //     - import ModuleSpecifier ;
        var result,
            cursor,
            that = this;

        // If no ImportClause is present,
        // this should be `import ModuleSpecifier` so skip `from`
        // ModuleSpecifier is StringLiteral.
        if (stmt.specifiers.length === 0) {
            // import ModuleSpecifier ;
            return [
                "import",
                space,
                // ModuleSpecifier
                this.generateExpression(
                    stmt.source,
                    Precedence.Sequence,
                    E_TTT
                ),
                this.semicolon(flags),
            ];
        }

        // import ImportClause FromClause ;
        result = ["import"];
        cursor = 0;

        // ImportedBinding
        if (stmt.specifiers[cursor].type === Syntax.ImportDefaultSpecifier) {
            result = join(result, [
                this.generateExpression(
                    stmt.specifiers[cursor],
                    Precedence.Sequence,
                    E_TTT
                ),
            ]);
            ++cursor;
        }

        if (stmt.specifiers[cursor]) {
            if (cursor !== 0) {
                result.push(",");
            }

            if (
                stmt.specifiers[cursor].type === Syntax.ImportNamespaceSpecifier
            ) {
                // NameSpaceImport
                result = join(result, [
                    space,
                    this.generateExpression(
                        stmt.specifiers[cursor],
                        Precedence.Sequence,
                        E_TTT
                    ),
                ]);
            } else {
                // NamedImports
                result.push(space + "{");

                if (stmt.specifiers.length - cursor === 1) {
                    // import { ... } from "...";
                    result.push(space);
                    result.push(
                        this.generateExpression(
                            stmt.specifiers[cursor],
                            Precedence.Sequence,
                            E_TTT
                        )
                    );
                    result.push(space + "}" + space);
                } else {
                    // import {
                    //    ...,
                    //    ...,
                    // } from "...";
                    withIndent(function (indent) {
                        var i, iz;
                        result.push(newline);
                        for (
                            i = cursor, iz = stmt.specifiers.length;
                            i < iz;
                            ++i
                        ) {
                            result.push(indent);
                            result.push(
                                that.generateExpression(
                                    stmt.specifiers[i],
                                    Precedence.Sequence,
                                    E_TTT
                                )
                            );
                            if (i + 1 < iz) {
                                result.push("," + newline);
                            }
                        }
                    });
                    if (
                        !endsWithLineTerminator(
                            toSourceNodeWhenNeeded(result).toString()
                        )
                    ) {
                        result.push(newline);
                    }
                    result.push(base + "}" + space);
                }
            }
        }

        result = join(result, [
            "from" + space,
            // ModuleSpecifier
            this.generateExpression(stmt.source, Precedence.Sequence, E_TTT),
            this.semicolon(flags),
        ]);
        return result;
    },

    VariableDeclarator: function (stmt, flags) {
        var itemFlags = flags & F_ALLOW_IN ? E_TTT : E_FTT;
        if (stmt.init) {
            return [
                this.generateExpression(
                    stmt.id,
                    Precedence.Assignment,
                    itemFlags
                ),
                space,
                "=",
                space,
                this.generateExpression(
                    stmt.init,
                    Precedence.Assignment,
                    itemFlags
                ),
            ];
        }
        return this.generatePattern(stmt.id, Precedence.Assignment, itemFlags);
    },

    VariableDeclaration: function (stmt, flags) {
        // VariableDeclarator is typed as Statement,
        // but joined with comma (not LineTerminator).
        // So if comment is attached to target node, we should specialize.
        var result,
            i,
            iz,
            node,
            bodyFlags,
            that = this;

        result = [stmt.kind];

        bodyFlags = flags & F_ALLOW_IN ? S_TFFF : S_FFFF;

        function block() {
            node = stmt.declarations[0];
            if (extra.comment && node.leadingComments) {
                result.push("\n");
                result.push(addIndent(that.generateStatement(node, bodyFlags)));
            } else {
                result.push(noEmptySpace());
                result.push(that.generateStatement(node, bodyFlags));
            }

            for (i = 1, iz = stmt.declarations.length; i < iz; ++i) {
                node = stmt.declarations[i];
                if (extra.comment && node.leadingComments) {
                    result.push("," + newline);
                    result.push(
                        addIndent(that.generateStatement(node, bodyFlags))
                    );
                } else {
                    result.push("," + space);
                    result.push(that.generateStatement(node, bodyFlags));
                }
            }
        }

        if (stmt.declarations.length > 1) {
            withIndent(block);
        } else {
            block();
        }

        result.push(this.semicolon(flags));

        return result;
    },

    ThrowStatement: function (stmt, flags) {
        return [
            join(
                "throw",
                this.generateExpression(
                    stmt.argument,
                    Precedence.Sequence,
                    E_TTT
                )
            ),
            this.semicolon(flags),
        ];
    },

    TryStatement: function (stmt) {
        var result, i, iz, guardedHandlers;

        result = ["try", this.maybeBlock(stmt.block, S_TFFF)];
        result = this.maybeBlockSuffix(stmt.block, result);

        if (stmt.handlers) {
            // old interface
            for (i = 0, iz = stmt.handlers.length; i < iz; ++i) {
                result = join(
                    result,
                    this.generateStatement(stmt.handlers[i], S_TFFF)
                );
                if (stmt.finalizer || i + 1 !== iz) {
                    result = this.maybeBlockSuffix(
                        stmt.handlers[i].body,
                        result
                    );
                }
            }
        } else {
            guardedHandlers = stmt.guardedHandlers || [];

            for (i = 0, iz = guardedHandlers.length; i < iz; ++i) {
                result = join(
                    result,
                    this.generateStatement(guardedHandlers[i], S_TFFF)
                );
                if (stmt.finalizer || i + 1 !== iz) {
                    result = this.maybeBlockSuffix(
                        guardedHandlers[i].body,
                        result
                    );
                }
            }

            // new interface
            if (stmt.handler) {
                if (Array.isArray(stmt.handler)) {
                    for (i = 0, iz = stmt.handler.length; i < iz; ++i) {
                        result = join(
                            result,
                            this.generateStatement(stmt.handler[i], S_TFFF)
                        );
                        if (stmt.finalizer || i + 1 !== iz) {
                            result = this.maybeBlockSuffix(
                                stmt.handler[i].body,
                                result
                            );
                        }
                    }
                } else {
                    result = join(
                        result,
                        this.generateStatement(stmt.handler, S_TFFF)
                    );
                    if (stmt.finalizer) {
                        result = this.maybeBlockSuffix(
                            stmt.handler.body,
                            result
                        );
                    }
                }
            }
        }
        if (stmt.finalizer) {
            result = join(result, [
                "finally",
                this.maybeBlock(stmt.finalizer, S_TFFF),
            ]);
        }
        return result;
    },

    SwitchStatement: function (stmt) {
        var result,
            fragment,
            i,
            iz,
            bodyFlags,
            that = this;
        withIndent(function () {
            result = [
                "switch" + space + "(",
                that.generateExpression(
                    stmt.discriminant,
                    Precedence.Sequence,
                    E_TTT
                ),
                ")" + space + "{" + newline,
            ];
        });
        if (stmt.cases) {
            bodyFlags = S_TFFF;
            for (i = 0, iz = stmt.cases.length; i < iz; ++i) {
                if (i === iz - 1) {
                    bodyFlags |= F_SEMICOLON_OPT;
                }
                fragment = addIndent(
                    this.generateStatement(stmt.cases[i], bodyFlags)
                );
                result.push(fragment);
                if (
                    !endsWithLineTerminator(
                        toSourceNodeWhenNeeded(fragment).toString()
                    )
                ) {
                    result.push(newline);
                }
            }
        }
        result.push(addIndent("}"));
        return result;
    },

    SwitchCase: function (stmt, flags) {
        var result,
            fragment,
            i,
            iz,
            bodyFlags,
            that = this;
        withIndent(function () {
            if (stmt.test) {
                result = [
                    join(
                        "case",
                        that.generateExpression(
                            stmt.test,
                            Precedence.Sequence,
                            E_TTT
                        )
                    ),
                    ":",
                ];
            } else {
                result = ["default:"];
            }

            i = 0;
            iz = stmt.consequent.length;
            if (iz && stmt.consequent[0].type === Syntax.BlockStatement) {
                fragment = that.maybeBlock(stmt.consequent[0], S_TFFF);
                result.push(fragment);
                i = 1;
            }

            if (
                i !== iz &&
                !endsWithLineTerminator(
                    toSourceNodeWhenNeeded(result).toString()
                )
            ) {
                result.push(newline);
            }

            bodyFlags = S_TFFF;
            for (; i < iz; ++i) {
                if (i === iz - 1 && flags & F_SEMICOLON_OPT) {
                    bodyFlags |= F_SEMICOLON_OPT;
                }
                fragment = addIndent(
                    that.generateStatement(stmt.consequent[i], bodyFlags)
                );
                result.push(fragment);
                if (
                    i + 1 !== iz &&
                    !endsWithLineTerminator(
                        toSourceNodeWhenNeeded(fragment).toString()
                    )
                ) {
                    result.push(newline);
                }
            }
        });
        return result;
    },

    IfStatement: function (stmt, flags) {
        var result,
            bodyFlags,
            semicolonOptional,
            that = this;
        withIndent(function () {
            result = [
                "if" + space + "(",
                that.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
                ")",
            ];
        });
        semicolonOptional = flags & F_SEMICOLON_OPT;
        bodyFlags = S_TFFF;
        if (semicolonOptional) {
            bodyFlags |= F_SEMICOLON_OPT;
        }
        if (stmt.alternate) {
            result.push(this.maybeBlock(stmt.consequent, S_TFFF));
            result = this.maybeBlockSuffix(stmt.consequent, result);
            if (stmt.alternate.type === Syntax.IfStatement) {
                result = join(result, [
                    "else ",
                    this.generateStatement(stmt.alternate, bodyFlags),
                ]);
            } else {
                result = join(
                    result,
                    join("else", this.maybeBlock(stmt.alternate, bodyFlags))
                );
            }
        } else {
            result.push(this.maybeBlock(stmt.consequent, bodyFlags));
        }
        return result;
    },

    ForStatement: function (stmt, flags) {
        var result,
            that = this;
        withIndent(function () {
            result = ["for" + space + "("];
            if (stmt.init) {
                if (stmt.init.type === Syntax.VariableDeclaration) {
                    result.push(that.generateStatement(stmt.init, S_FFFF));
                } else {
                    // F_ALLOW_IN becomes false.
                    result.push(
                        that.generateExpression(
                            stmt.init,
                            Precedence.Sequence,
                            E_FTT
                        )
                    );
                    result.push(";");
                }
            } else {
                result.push(";");
            }

            if (stmt.test) {
                result.push(space);
                result.push(
                    that.generateExpression(
                        stmt.test,
                        Precedence.Sequence,
                        E_TTT
                    )
                );
                result.push(";");
            } else {
                result.push(";");
            }

            if (stmt.update) {
                result.push(space);
                result.push(
                    that.generateExpression(
                        stmt.update,
                        Precedence.Sequence,
                        E_TTT
                    )
                );
                result.push(")");
            } else {
                result.push(")");
            }
        });

        result.push(
            this.maybeBlock(
                stmt.body,
                flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF
            )
        );
        return result;
    },

    ForInStatement: function (stmt, flags) {
        return this.generateIterationForStatement(
            "in",
            stmt,
            flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF
        );
    },

    ForOfStatement: function (stmt, flags) {
        return this.generateIterationForStatement(
            "of",
            stmt,
            flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF
        );
    },

    LabeledStatement: function (stmt, flags) {
        return [
            stmt.label.name + ":",
            this.maybeBlock(
                stmt.body,
                flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF
            ),
        ];
    },

    Program: function (stmt) {
        var result, fragment, i, iz, bodyFlags;
        iz = stmt.body.length;
        result = [safeConcatenation && iz > 0 ? "\n" : ""];
        bodyFlags = S_TFTF;
        for (i = 0; i < iz; ++i) {
            if (!safeConcatenation && i === iz - 1) {
                bodyFlags |= F_SEMICOLON_OPT;
            }

            if (preserveBlankLines) {
                // handle spaces before the first line
                if (i === 0) {
                    if (!stmt.body[0].leadingComments) {
                        generateBlankLines(
                            stmt.range[0],
                            stmt.body[i].range[0],
                            result
                        );
                    }
                }

                // handle spaces between lines
                if (i > 0) {
                    if (
                        !stmt.body[i - 1].trailingComments &&
                        !stmt.body[i].leadingComments
                    ) {
                        generateBlankLines(
                            stmt.body[i - 1].range[1],
                            stmt.body[i].range[0],
                            result
                        );
                    }
                }
            }

            fragment = addIndent(
                this.generateStatement(stmt.body[i], bodyFlags)
            );
            result.push(fragment);
            if (
                i + 1 < iz &&
                !endsWithLineTerminator(
                    toSourceNodeWhenNeeded(fragment).toString()
                )
            ) {
                if (preserveBlankLines) {
                    if (!stmt.body[i + 1].leadingComments) {
                        result.push(newline);
                    }
                } else {
                    result.push(newline);
                }
            }

            if (preserveBlankLines) {
                // handle spaces after the last line
                if (i === iz - 1) {
                    if (!stmt.body[i].trailingComments) {
                        generateBlankLines(
                            stmt.body[i].range[1],
                            stmt.range[1],
                            result
                        );
                    }
                }
            }
        }
        return result;
    },

    FunctionDeclaration: function (stmt) {
        return [
            generateAsyncPrefix(stmt, true),
            "function",
            generateStarSuffix(stmt) || noEmptySpace(),
            stmt.id ? generateIdentifier(stmt.id) : "",
            this.generateFunctionBody(stmt),
        ];
    },

    ReturnStatement: function (stmt, flags) {
        if (stmt.argument) {
            return [
                join(
                    "return",
                    this.generateExpression(
                        stmt.argument,
                        Precedence.Sequence,
                        E_TTT
                    )
                ),
                this.semicolon(flags),
            ];
        }
        return ["return" + this.semicolon(flags)];
    },

    WhileStatement: function (stmt, flags) {
        var result,
            that = this;
        withIndent(function () {
            result = [
                "while" + space + "(",
                that.generateExpression(stmt.test, Precedence.Sequence, E_TTT),
                ")",
            ];
        });
        result.push(
            this.maybeBlock(
                stmt.body,
                flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF
            )
        );
        return result;
    },

    WithStatement: function (stmt, flags) {
        var result,
            that = this;
        withIndent(function () {
            result = [
                "with" + space + "(",
                that.generateExpression(
                    stmt.object,
                    Precedence.Sequence,
                    E_TTT
                ),
                ")",
            ];
        });
        result.push(
            this.maybeBlock(
                stmt.body,
                flags & F_SEMICOLON_OPT ? S_TFFT : S_TFFF
            )
        );
        return result;
    },
};

merge(CodeGenerator.prototype, CodeGenerator.Statement);

// Expressions.

CodeGenerator.Expression = {
    SequenceExpression: function (expr, precedence, flags) {
        var result, i, iz;
        if (Precedence.Sequence < precedence) {
            flags |= F_ALLOW_IN;
        }
        result = [];
        for (i = 0, iz = expr.expressions.length; i < iz; ++i) {
            result.push(
                this.generateExpression(
                    expr.expressions[i],
                    Precedence.Assignment,
                    flags
                )
            );
            if (i + 1 < iz) {
                result.push("," + space);
            }
        }
        return parenthesize(result, Precedence.Sequence, precedence);
    },

    AssignmentExpression: function (expr, precedence, flags) {
        return this.generateAssignment(
            expr.left,
            expr.right,
            expr.operator,
            precedence,
            flags
        );
    },

    ArrowFunctionExpression: function (expr, precedence) {
        return parenthesize(
            this.generateFunctionBody(expr),
            Precedence.ArrowFunction,
            precedence
        );
    },

    ConditionalExpression: function (expr, precedence, flags) {
        if (Precedence.Conditional < precedence) {
            flags |= F_ALLOW_IN;
        }
        return parenthesize(
            [
                this.generateExpression(expr.test, Precedence.LogicalOR, flags),
                space + "?" + space,
                this.generateExpression(
                    expr.consequent,
                    Precedence.Assignment,
                    flags
                ),
                space + ":" + space,
                this.generateExpression(
                    expr.alternate,
                    Precedence.Assignment,
                    flags
                ),
            ],
            Precedence.Conditional,
            precedence
        );
    },

    LogicalExpression: function (expr, precedence, flags) {
        return this.BinaryExpression(expr, precedence, flags);
    },

    BinaryExpression: function (expr, precedence, flags) {
        var result, currentPrecedence, fragment, leftSource;
        currentPrecedence = BinaryPrecedence[expr.operator];

        if (currentPrecedence < precedence) {
            flags |= F_ALLOW_IN;
        }

        fragment = this.generateExpression(expr.left, currentPrecedence, flags);

        leftSource = fragment.toString();

        if (
            leftSource.charCodeAt(leftSource.length - 1) === 0x2f /* / */ &&
            esutilscode.isIdentifierPartES5(expr.operator.charCodeAt(0))
        ) {
            result = [fragment, noEmptySpace(), expr.operator];
        } else {
            result = join(fragment, expr.operator);
        }

        fragment = this.generateExpression(
            expr.right,
            currentPrecedence + 1,
            flags
        );

        if (
            (expr.operator === "/" && fragment.toString().charAt(0) === "/") ||
            (expr.operator.slice(-1) === "<" &&
                fragment.toString().slice(0, 3) === "!--")
        ) {
            // If '/' concats with '/' or `<` concats with `!--`, it is interpreted as comment start
            result.push(noEmptySpace());
            result.push(fragment);
        } else {
            result = join(result, fragment);
        }

        if (expr.operator === "in" && !(flags & F_ALLOW_IN)) {
            return ["(", result, ")"];
        }
        return parenthesize(result, currentPrecedence, precedence);
    },

    CallExpression: function (expr, precedence, flags) {
        var result, i, iz;
        // F_ALLOW_UNPARATH_NEW becomes false.
        result = [this.generateExpression(expr.callee, Precedence.Call, E_TTF)];
        result.push("(");
        for (i = 0, iz = expr["arguments"].length; i < iz; ++i) {
            result.push(
                this.generateExpression(
                    expr["arguments"][i],
                    Precedence.Assignment,
                    E_TTT
                )
            );
            if (i + 1 < iz) {
                result.push("," + space);
            }
        }
        result.push(")");

        if (!(flags & F_ALLOW_CALL)) {
            return ["(", result, ")"];
        }
        return parenthesize(result, Precedence.Call, precedence);
    },

    NewExpression: function (expr, precedence, flags) {
        var result, length, i, iz, itemFlags;
        length = expr["arguments"].length;

        // F_ALLOW_CALL becomes false.
        // F_ALLOW_UNPARATH_NEW may become false.
        itemFlags =
            flags & F_ALLOW_UNPARATH_NEW && !parentheses && length === 0
                ? E_TFT
                : E_TFF;

        result = join(
            "new",
            this.generateExpression(expr.callee, Precedence.New, itemFlags)
        );

        if (!(flags & F_ALLOW_UNPARATH_NEW) || parentheses || length > 0) {
            result.push("(");
            for (i = 0, iz = length; i < iz; ++i) {
                result.push(
                    this.generateExpression(
                        expr["arguments"][i],
                        Precedence.Assignment,
                        E_TTT
                    )
                );
                if (i + 1 < iz) {
                    result.push("," + space);
                }
            }
            result.push(")");
        }

        return parenthesize(result, Precedence.New, precedence);
    },

    MemberExpression: function (expr, precedence, flags) {
        var result, fragment;

        // F_ALLOW_UNPARATH_NEW becomes false.
        result = [
            this.generateExpression(
                expr.object,
                Precedence.Call,
                flags & F_ALLOW_CALL ? E_TTF : E_TFF
            ),
        ];

        if (expr.computed) {
            result.push("[");
            result.push(
                this.generateExpression(
                    expr.property,
                    Precedence.Sequence,
                    flags & F_ALLOW_CALL ? E_TTT : E_TFT
                )
            );
            result.push("]");
        } else {
            if (
                expr.object.type === Syntax.Literal &&
                typeof expr.object.value === "number"
            ) {
                fragment = toSourceNodeWhenNeeded(result).toString();
                // When the following conditions are all true,
                //   1. No floating point
                //   2. Don't have exponents
                //   3. The last character is a decimal digit
                //   4. Not hexadecimal OR octal number literal
                // we should add a floating point.
                if (
                    fragment.indexOf(".") < 0 &&
                    !/[eExX]/.test(fragment) &&
                    esutilscode.isDecimalDigit(
                        fragment.charCodeAt(fragment.length - 1)
                    ) &&
                    !(fragment.length >= 2 && fragment.charCodeAt(0) === 48) // '0'
                ) {
                    result.push(" ");
                }
            }
            result.push(".");
            result.push(generateIdentifier(expr.property));
        }

        return parenthesize(result, Precedence.Member, precedence);
    },

    MetaProperty: function (expr, precedence) {
        var result;
        result = [];
        result.push(
            typeof expr.meta === "string"
                ? expr.meta
                : generateIdentifier(expr.meta)
        );
        result.push(".");
        result.push(
            typeof expr.property === "string"
                ? expr.property
                : generateIdentifier(expr.property)
        );
        return parenthesize(result, Precedence.Member, precedence);
    },

    UnaryExpression: function (expr, precedence) {
        var result, fragment, rightCharCode, leftSource, leftCharCode;
        fragment = this.generateExpression(
            expr.argument,
            Precedence.Unary,
            E_TTT
        );

        if (space === "") {
            result = join(expr.operator, fragment);
        } else {
            result = [expr.operator];
            if (expr.operator.length > 2) {
                // delete, void, typeof
                // get `typeof []`, not `typeof[]`
                result = join(result, fragment);
            } else {
                // Prevent inserting spaces between operator and argument if it is unnecessary
                // like, `!cond`
                leftSource = toSourceNodeWhenNeeded(result).toString();
                leftCharCode = leftSource.charCodeAt(leftSource.length - 1);
                rightCharCode = fragment.toString().charCodeAt(0);

                if (
                    ((leftCharCode === 0x2b /* + */ ||
                        leftCharCode === 0x2d) /* - */ &&
                        leftCharCode === rightCharCode) ||
                    (esutilscode.isIdentifierPartES5(leftCharCode) &&
                        esutilscode.isIdentifierPartES5(rightCharCode))
                ) {
                    result.push(noEmptySpace());
                    result.push(fragment);
                } else {
                    result.push(fragment);
                }
            }
        }
        return parenthesize(result, Precedence.Unary, precedence);
    },

    YieldExpression: function (expr, precedence) {
        var result;
        if (expr.delegate) {
            result = "yield*";
        } else {
            result = "yield";
        }
        if (expr.argument) {
            result = join(
                result,
                this.generateExpression(expr.argument, Precedence.Yield, E_TTT)
            );
        }
        return parenthesize(result, Precedence.Yield, precedence);
    },

    AwaitExpression: function (expr, precedence) {
        var result = join(
            expr.all ? "await*" : "await",
            this.generateExpression(expr.argument, Precedence.Await, E_TTT)
        );
        return parenthesize(result, Precedence.Await, precedence);
    },

    UpdateExpression: function (expr, precedence) {
        if (expr.prefix) {
            return parenthesize(
                [
                    expr.operator,
                    this.generateExpression(
                        expr.argument,
                        Precedence.Unary,
                        E_TTT
                    ),
                ],
                Precedence.Unary,
                precedence
            );
        }
        return parenthesize(
            [
                this.generateExpression(
                    expr.argument,
                    Precedence.Postfix,
                    E_TTT
                ),
                expr.operator,
            ],
            Precedence.Postfix,
            precedence
        );
    },

    FunctionExpression: function (expr) {
        var result = [generateAsyncPrefix(expr, true), "function"];
        if (expr.id) {
            result.push(generateStarSuffix(expr) || noEmptySpace());
            result.push(generateIdentifier(expr.id));
        } else {
            result.push(generateStarSuffix(expr) || space);
        }
        result.push(this.generateFunctionBody(expr));
        return result;
    },

    ArrayPattern: function (expr, precedence, flags) {
        return this.ArrayExpression(expr, precedence, flags, true);
    },

    ArrayExpression: function (expr, precedence, flags, isPattern) {
        var result,
            multiline,
            that = this;
        if (!expr.elements.length) {
            return "[]";
        }
        multiline = isPattern ? false : expr.elements.length > 1;
        result = ["[", multiline ? newline : ""];
        withIndent(function (indent) {
            var i, iz;
            for (i = 0, iz = expr.elements.length; i < iz; ++i) {
                if (!expr.elements[i]) {
                    if (multiline) {
                        result.push(indent);
                    }
                    if (i + 1 === iz) {
                        result.push(",");
                    }
                } else {
                    result.push(multiline ? indent : "");
                    result.push(
                        that.generateExpression(
                            expr.elements[i],
                            Precedence.Assignment,
                            E_TTT
                        )
                    );
                }
                if (i + 1 < iz) {
                    result.push("," + (multiline ? newline : space));
                }
            }
        });
        if (
            multiline &&
            !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())
        ) {
            result.push(newline);
        }
        result.push(multiline ? base : "");
        result.push("]");
        return result;
    },

    RestElement: function (expr) {
        return "..." + this.generatePattern(expr.argument);
    },

    ClassExpression: function (expr) {
        var result, fragment;
        result = ["class"];
        if (expr.id) {
            result = join(
                result,
                this.generateExpression(expr.id, Precedence.Sequence, E_TTT)
            );
        }
        if (expr.superClass) {
            fragment = join(
                "extends",
                this.generateExpression(
                    expr.superClass,
                    Precedence.Assignment,
                    E_TTT
                )
            );
            result = join(result, fragment);
        }
        result.push(space);
        result.push(this.generateStatement(expr.body, S_TFFT));
        return result;
    },

    MethodDefinition: function (expr) {
        var result, fragment;
        if (expr["static"]) {
            result = ["static" + space];
        } else {
            result = [];
        }
        if (expr.kind === "get" || expr.kind === "set") {
            fragment = [
                join(
                    expr.kind,
                    this.generatePropertyKey(expr.key, expr.computed)
                ),
                this.generateFunctionBody(expr.value),
            ];
        } else {
            fragment = [
                generateMethodPrefix(expr),
                this.generatePropertyKey(expr.key, expr.computed),
                this.generateFunctionBody(expr.value),
            ];
        }
        return join(result, fragment);
    },

    Property: function (expr) {
        if (expr.kind === "get" || expr.kind === "set") {
            return [
                expr.kind,
                noEmptySpace(),
                this.generatePropertyKey(expr.key, expr.computed),
                this.generateFunctionBody(expr.value),
            ];
        }

        if (expr.shorthand) {
            if (expr.value.type === "AssignmentPattern") {
                return this.AssignmentPattern(
                    expr.value,
                    Precedence.Sequence,
                    E_TTT
                );
            }
            return this.generatePropertyKey(expr.key, expr.computed);
        }

        if (expr.method) {
            return [
                generateMethodPrefix(expr),
                this.generatePropertyKey(expr.key, expr.computed),
                this.generateFunctionBody(expr.value),
            ];
        }

        return [
            this.generatePropertyKey(expr.key, expr.computed),
            ":" + space,
            this.generateExpression(expr.value, Precedence.Assignment, E_TTT),
        ];
    },

    ObjectExpression: function (expr) {
        var multiline,
            result,
            fragment,
            that = this;

        if (!expr.properties.length) {
            return "{}";
        }
        multiline = expr.properties.length > 1;

        withIndent(function () {
            fragment = that.generateExpression(
                expr.properties[0],
                Precedence.Sequence,
                E_TTT
            );
        });

        if (!multiline) {
            // issues 4
            // Do not transform from
            //   dejavu.Class.declare({
            //       method2: function () {}
            //   });
            // to
            //   dejavu.Class.declare({method2: function () {
            //       }});
            if (
                !hasLineTerminator(toSourceNodeWhenNeeded(fragment).toString())
            ) {
                return ["{", space, fragment, space, "}"];
            }
        }

        withIndent(function (indent) {
            var i, iz;
            result = ["{", newline, indent, fragment];

            if (multiline) {
                result.push("," + newline);
                for (i = 1, iz = expr.properties.length; i < iz; ++i) {
                    result.push(indent);
                    result.push(
                        that.generateExpression(
                            expr.properties[i],
                            Precedence.Sequence,
                            E_TTT
                        )
                    );
                    if (i + 1 < iz) {
                        result.push("," + newline);
                    }
                }
            }
        });

        if (
            !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())
        ) {
            result.push(newline);
        }
        result.push(base);
        result.push("}");
        return result;
    },

    AssignmentPattern: function (expr, precedence, flags) {
        return this.generateAssignment(
            expr.left,
            expr.right,
            "=",
            precedence,
            flags
        );
    },

    ObjectPattern: function (expr) {
        var result,
            i,
            iz,
            multiline,
            property,
            that = this;
        if (!expr.properties.length) {
            return "{}";
        }

        multiline = false;
        if (expr.properties.length === 1) {
            property = expr.properties[0];
            if (property.value.type !== Syntax.Identifier) {
                multiline = true;
            }
        } else {
            for (i = 0, iz = expr.properties.length; i < iz; ++i) {
                property = expr.properties[i];
                if (!property.shorthand) {
                    multiline = true;
                    break;
                }
            }
        }
        result = ["{", multiline ? newline : ""];

        withIndent(function (indent) {
            var i, iz;
            for (i = 0, iz = expr.properties.length; i < iz; ++i) {
                result.push(multiline ? indent : "");
                result.push(
                    that.generateExpression(
                        expr.properties[i],
                        Precedence.Sequence,
                        E_TTT
                    )
                );
                if (i + 1 < iz) {
                    result.push("," + (multiline ? newline : space));
                }
            }
        });

        if (
            multiline &&
            !endsWithLineTerminator(toSourceNodeWhenNeeded(result).toString())
        ) {
            result.push(newline);
        }
        result.push(multiline ? base : "");
        result.push("}");
        return result;
    },

    ThisExpression: function () {
        return "this";
    },

    Super: function () {
        return "super";
    },

    Identifier: function (expr) {
        return generateIdentifier(expr);
    },

    ImportDefaultSpecifier: function (expr) {
        return generateIdentifier(expr.id || expr.local);
    },

    ImportNamespaceSpecifier: function (expr) {
        var result = ["*"];
        var id = expr.id || expr.local;
        if (id) {
            result.push(space + "as" + noEmptySpace() + generateIdentifier(id));
        }
        return result;
    },

    ImportSpecifier: function (expr) {
        var imported = expr.imported;
        var result = [imported.name];
        var local = expr.local;
        if (local && local.name !== imported.name) {
            result.push(
                noEmptySpace() +
                    "as" +
                    noEmptySpace() +
                    generateIdentifier(local)
            );
        }
        return result;
    },

    ExportSpecifier: function (expr) {
        var local = expr.local;
        var result = [local.name];
        var exported = expr.exported;
        if (exported && exported.name !== local.name) {
            result.push(
                noEmptySpace() +
                    "as" +
                    noEmptySpace() +
                    generateIdentifier(exported)
            );
        }
        return result;
    },

    Literal: function (expr) {
        var raw;
        if (expr.hasOwnProperty("raw") && parse && extra.raw) {
            try {
                raw = parse(expr.raw).body[0].expression;
                if (raw.type === Syntax.Literal) {
                    if (raw.value === expr.value) {
                        return expr.raw;
                    }
                }
            } catch (e) {
                // not use raw property
            }
        }

        if (expr.value === null) {
            return "null";
        }

        if (typeof expr.value === "string") {
            return escapeString(expr.value);
        }

        if (typeof expr.value === "number") {
            return generateNumber(expr.value);
        }

        if (typeof expr.value === "boolean") {
            return expr.value ? "true" : "false";
        }

        if (expr.regex) {
            return "/" + expr.regex.pattern + "/" + expr.regex.flags;
        }
        return generateRegExp(expr.value);
    },

    GeneratorExpression: function (expr, precedence, flags) {
        return this.ComprehensionExpression(expr, precedence, flags);
    },

    ComprehensionExpression: function (expr) {
        // GeneratorExpression should be parenthesized with (...), ComprehensionExpression with [...]
        // Due to https://bugzilla.mozilla.org/show_bug.cgi?id=883468 position of expr.body can differ in Spidermonkey and ES6

        var result,
            i,
            iz,
            fragment,
            that = this;
        result = expr.type === Syntax.GeneratorExpression ? ["("] : ["["];

        if (extra.moz.comprehensionExpressionStartsWithAssignment) {
            fragment = this.generateExpression(
                expr.body,
                Precedence.Assignment,
                E_TTT
            );
            result.push(fragment);
        }

        if (expr.blocks) {
            withIndent(function () {
                for (i = 0, iz = expr.blocks.length; i < iz; ++i) {
                    fragment = that.generateExpression(
                        expr.blocks[i],
                        Precedence.Sequence,
                        E_TTT
                    );
                    if (
                        i > 0 ||
                        extra.moz.comprehensionExpressionStartsWithAssignment
                    ) {
                        result = join(result, fragment);
                    } else {
                        result.push(fragment);
                    }
                }
            });
        }

        if (expr.filter) {
            result = join(result, "if" + space);
            fragment = this.generateExpression(
                expr.filter,
                Precedence.Sequence,
                E_TTT
            );
            result = join(result, ["(", fragment, ")"]);
        }

        if (!extra.moz.comprehensionExpressionStartsWithAssignment) {
            fragment = this.generateExpression(
                expr.body,
                Precedence.Assignment,
                E_TTT
            );

            result = join(result, fragment);
        }

        result.push(expr.type === Syntax.GeneratorExpression ? ")" : "]");
        return result;
    },

    ComprehensionBlock: function (expr) {
        var fragment;
        if (expr.left.type === Syntax.VariableDeclaration) {
            fragment = [
                expr.left.kind,
                noEmptySpace(),
                this.generateStatement(expr.left.declarations[0], S_FFFF),
            ];
        } else {
            fragment = this.generateExpression(
                expr.left,
                Precedence.Call,
                E_TTT
            );
        }

        fragment = join(fragment, expr.of ? "of" : "in");
        fragment = join(
            fragment,
            this.generateExpression(expr.right, Precedence.Sequence, E_TTT)
        );

        return ["for" + space + "(", fragment, ")"];
    },

    SpreadElement: function (expr) {
        return [
            "...",
            this.generateExpression(
                expr.argument,
                Precedence.Assignment,
                E_TTT
            ),
        ];
    },

    TaggedTemplateExpression: function (expr, precedence, flags) {
        var itemFlags = E_TTF;
        if (!(flags & F_ALLOW_CALL)) {
            itemFlags = E_TFF;
        }
        var result = [
            this.generateExpression(expr.tag, Precedence.Call, itemFlags),
            this.generateExpression(expr.quasi, Precedence.Primary, E_FFT),
        ];
        return parenthesize(result, Precedence.TaggedTemplate, precedence);
    },

    TemplateElement: function (expr) {
        // Don't use "cooked". Since tagged template can use raw template
        // representation. So if we do so, it breaks the script semantics.
        return expr.value.raw;
    },

    TemplateLiteral: function (expr) {
        var result, i, iz;
        result = ["`"];
        for (i = 0, iz = expr.quasis.length; i < iz; ++i) {
            result.push(
                this.generateExpression(
                    expr.quasis[i],
                    Precedence.Primary,
                    E_TTT
                )
            );
            if (i + 1 < iz) {
                result.push("${" + space);
                result.push(
                    this.generateExpression(
                        expr.expressions[i],
                        Precedence.Sequence,
                        E_TTT
                    )
                );
                result.push(space + "}");
            }
        }
        result.push("`");
        return result;
    },

    ModuleSpecifier: function (expr, precedence, flags) {
        return this.Literal(expr, precedence, flags);
    },
};

merge(CodeGenerator.prototype, CodeGenerator.Expression);

CodeGenerator.prototype.generateExpression = function (
    expr,
    precedence,
    flags
) {
    var result, type;

    type = expr.type || Syntax.Property;

    if (extra.verbatim && expr.hasOwnProperty(extra.verbatim)) {
        return generateVerbatim(expr, precedence);
    }

    result = this[type](expr, precedence, flags);

    if (extra.comment) {
        result = addComments(expr, result);
    }
    return toSourceNodeWhenNeeded(result, expr);
};

CodeGenerator.prototype.generateStatement = function (stmt, flags) {
    var result, fragment;

    result = this[stmt.type](stmt, flags);

    // Attach comments

    if (extra.comment) {
        result = addComments(stmt, result);
    }

    fragment = toSourceNodeWhenNeeded(result).toString();
    if (
        stmt.type === Syntax.Program &&
        !safeConcatenation &&
        newline === "" &&
        fragment.charAt(fragment.length - 1) === "\n"
    ) {
        result = sourceMap
            ? toSourceNodeWhenNeeded(result).replaceRight(/\s+$/, "")
            : fragment.replace(/\s+$/, "");
    }

    return toSourceNodeWhenNeeded(result, stmt);
};

function generateInternal(node) {
    var codegen;

    codegen = new CodeGenerator();
    if (isStatement(node)) {
        return codegen.generateStatement(node, S_TFFF);
    }

    if (isExpression(node)) {
        return codegen.generateExpression(node, Precedence.Sequence, E_TTT);
    }

    throw new Error("Unknown node type: " + node.type);
}
/**
 * @param {any} node
 * @param {import("escodegen").GenerateOptions} options
 * @returns {string}
 */
function generate(node, options) {
    var defaultOptions = getDefaultOptions(),
        result,
        pair;

    if (options != null) {
        // Obsolete options
        //
        //   `options.indent`
        //   `options.base`
        //
        // Instead of them, we can use `option.format.indent`.
        if (typeof options.indent === "string") {
            defaultOptions.format.indent.style = options.indent;
        }
        if (typeof options.base === "number") {
            defaultOptions.format.indent.base = options.base;
        }
        options = updateDeeply(defaultOptions, options);
        indent = options.format.indent.style;
        if (typeof options.base === "string") {
            base = options.base;
        } else {
            base = stringRepeat(indent, options.format.indent.base);
        }
    } else {
        options = defaultOptions;
        indent = options.format.indent.style;
        base = stringRepeat(indent, options.format.indent.base);
    }
    json = options.format.json;
    renumber = options.format.renumber;
    hexadecimal = json ? false : options.format.hexadecimal;
    quotes = json ? "double" : options.format.quotes;
    escapeless = options.format.escapeless;
    newline = options.format.newline;
    space = options.format.space;
    if (options.format.compact) {
        newline = space = indent = base = "";
    }
    parentheses = options.format.parentheses;
    semicolons = options.format.semicolons;
    safeConcatenation = options.format.safeConcatenation;
    directive = options.directive;
    parse = json ? null : options.parse;
    sourceMap = options.sourceMap;
    sourceCode = options.sourceCode;
    preserveBlankLines =
        options.format.preserveBlankLines && sourceCode !== null;
    extra = options;

    if (sourceMap) {
        if (!browser) {
            SourceNode = function () {};
            // We assume environment is node.js
            // And prevent from including source-map by browserify
            // SourceNode = require('source-map').SourceNode;
        } else {
            // SourceNode = global.sourceMap.SourceNode;
            SourceNode = function () {};
        }
    }

    result = generateInternal(node);

    if (!sourceMap) {
        pair = { code: result.toString(), map: null };
        return options.sourceMapWithCode ? pair : pair.code;
    }

    pair = result.toStringWithSourceMap({
        file: options.file,
        sourceRoot: options.sourceMapRoot,
    });

    if (options.sourceContent) {
        pair.map.setSourceContent(options.sourceMap, options.sourceContent);
    }

    if (options.sourceMapWithCode) {
        return pair;
    }

    return pair.map.toString();
}

FORMAT_MINIFY = {
    indent: {
        style: "",
        base: 0,
    },
    renumber: true,
    hexadecimal: true,
    quotes: "auto",
    escapeless: true,
    compact: true,
    parentheses: false,
    semicolons: false,
};

FORMAT_DEFAULTS = getDefaultOptions().format;

export const version = "1.11.1";
const _generate = generate;
export { _generate as generate };
// export const attachComments = estraverse.attachComments;
const _Precedence = updateDeeply({}, Precedence);
export { _Precedence as Precedence };
export const browser = true;
const _FORMAT_MINIFY = FORMAT_MINIFY;
export { _FORMAT_MINIFY as FORMAT_MINIFY };
const _FORMAT_DEFAULTS = FORMAT_DEFAULTS;
export { _FORMAT_DEFAULTS as FORMAT_DEFAULTS };
// }());
/* vim: set sw=4 ts=4 et tw=80 : */
